home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Cream of the Crop 11
/
Cream of the Crop 11-1.iso
/
games
/
ted5.zip
/
MEMMGR.C
< prev
next >
Wrap
C/C++ Source or Header
|
1993-02-04
|
15KB
|
782 lines
#include "ted5.h"
#pragma hdrstop
#define EMSINT 0x67
#define SPACEFREE 0x2000 // how much mem to leave alone in farheap
#define EXTRASTACKSIZE 0x2000
#define MAXBLOCKS 1000
#define LOCKBIT 0x8000 // if set in attributes, block cannot be moved
#define PURGEBITS 3 // 0-3 level, 0= unpurgable, 3= purge first
#define BASEATTRIBUTES 0 // unlocked, non purgable
unsigned totalmem; // total paragraphs available with 64k EMS
int EMSpresent,XMSpresent;
long TTLMainMem;
void far *farheap;
void *nearheap;
int numblocks;
struct {
unsigned start; // in paragraphs
unsigned length;
unsigned attributes;
memptr *useptr;
} blocks[MAXBLOCKS],tempblock;
//==========================================================================
//
// local prototypes
//
void CheckForEMS (void);
int FindBlock (memptr *ptr);
void RemoveBlock (int block);
void InsertBlock (int block);
//
// public prototypes
//
void MMStartup (void);
void MMShutdown (void);
void MMMapEMS (void);
void MMGetPtr (memptr *baseptr,unsigned size);
void MMFreePtr (memptr *baseptr);
void MMSetPurge (memptr *baseptr, int purge);
void MMSortMem (void);
void MMBlockDump (void);
unsigned MMUnusedMemory (void);
unsigned MMTotalFree (void);
//==========================================================================
//
// CheckForEMS
//
// Routine from p36 of Extending DOS
//
void CheckForEMS (void)
{
char emmname[9] = "EMMXXXX0";
asm mov dx,OFFSET emmname
asm mov ax,0x3d00
asm int 0x21 // try to open EMMXXXX0 device
asm jc error
asm mov bx,ax
asm mov ax,0x4400
asm int 0x21 // get device info
asm jc error
asm and dx,0x80
asm jz error
asm mov ax,0x4407
asm int 0x21 // get status
asm jc error
asm or al,al
asm jz error
asm mov ah,0x3e
asm int 0x21 // close handle
asm jc error
//
// EMS is good
//
return;
error:
//
// EMS is bad
//
EMSpresent = 0;
}
//==========================================================================
//
// FindBlock
//
int FindBlock (memptr *ptr)
{
int i;
for (i=1;i<numblocks;i++)
if (blocks[i].useptr == ptr)
return i;
Quit ("Memory manager error: Block not found!");
return -1;
}
//
// RemoveBlock
// 0 the pointer, close the block array down, and decrement numblocks
//
void RemoveBlock (int block)
{
void far *source, far *dest;
unsigned length;
*blocks[block].useptr = NULL;
if (block!=numblocks-1)
{
source = &blocks[block+1];
dest = &blocks[block];
length = (numblocks-1-block)*sizeof(blocks[0]);
movedata (FP_SEG(source),FP_OFF(source),FP_SEG(dest),FP_OFF(dest),length);
}
numblocks--;
}
//
// InsertBlock
// Inserts space in the block array AFTER parameter and increments numblocks
//
void InsertBlock (int block)
{
unsigned source,dest,length;
if (block!=numblocks-1)
{
source = ((unsigned)&blocks[numblocks])-2;
dest = ((unsigned)&blocks[numblocks+1])-2;
length = (numblocks-1-block)*sizeof(blocks[0])/2;
asm mov cx,length
asm mov si,source
asm mov di,dest
asm mov ax,ds
asm mov es,ax
asm std
asm rep movsw
asm cld
}
if (++numblocks>=MAXBLOCKS)
Quit ("Memory manager error: Too many blocks!");
}
// check numblocks<MAXBLOCKS
//==========================================================================
/*
===================
=
= MMStartup
=
= Initializes the memory manager and returns the total
= allocatable free space.
=
= Grabs all space from turbo with farmalloc
=
===================
*/
void MMStartup (void)
{
unsigned long length;
void far *start;
unsigned nearstart,farstart,EMSstart,seg,i;
unsigned nearlength,farlength,emslength,xmslength;
//
// get all available near conventional memory
//
length=coreleft();
start = (void far *)(nearheap = malloc(length-SPACEFREE));
//
// paragraph align it and figure size
//
length -= 16-(FP_OFF(start)&15);
length -= EXTRASTACKSIZE;
nearlength = length / 16; // now in paragraphs
nearstart = FP_SEG(start)+(FP_OFF(start)+15)/16;
//
// get all available far conventional memory
//
length=farcoreleft();
start = farheap = farmalloc(length);
//
// paragraph align it and figure size
//
if (FP_OFF(start))
{
length -= 16-FP_OFF(start);
start = (void far *)MK_FP(FP_SEG(start)+1,0);
}
farlength = length / 16; // now in paragraphs
farstart = FP_SEG(start);
totalmem = nearlength + farlength;
//
// detect EMS and allocate 64K at page frame
//
CheckForEMS();
if (EMSpresent)
{
EMSstart = 0xffff;
totalmem += 0x1000; // 64k of EMS
MMMapEMS(); // map in used pages
}
else
{
EMSstart = 0xffff;
}
//
// set up locked blocks
//
numblocks = 0;
blocks[numblocks].start = 0;
blocks[numblocks].length = nearstart;
blocks[numblocks].attributes = LOCKBIT;
numblocks++;
blocks[numblocks].start = nearstart+nearlength;
blocks[numblocks].length = farstart-(nearstart+nearlength);
blocks[numblocks].attributes = LOCKBIT;
numblocks++;
blocks[numblocks].start = farstart+farlength;
blocks[numblocks].length = EMSstart-(farstart+farlength);
blocks[numblocks].attributes = LOCKBIT;
numblocks++;
TTLMainMem=16L*MMTotalFree();
}
//==========================================================================
/*
====================
=
= MMShutdown
=
= Frees all conventional, EMS, and XMS allocated
=
====================
*/
void MMShutdown (void)
{
int i;
//
// 0 the pointers (if any)
//
for (i=0;i<numblocks-1;i++)
*blocks[i].useptr=NULL;
farfree (farheap);
free (nearheap);
}
//==========================================================================
/*
====================
=
= MMMapEMS
=
= Maps the 64k of EMS used by memory manager into the page frame
= for general use.
=
====================
*/
void MMMapEMS (void)
{
}
//==========================================================================
/*
====================
=
= MMGetPtr
=
= Allocates an unlocked, unpurgable block
= Start looking at the top of memory
=
====================
*/
void MMAllocate(memptr *baseptr,long size)
{
MMGetPtr(baseptr,(unsigned)((size+15)/16));
TTLMainMem=16L*MMTotalFree();
}
void MMGetPtr (memptr *baseptr,unsigned size)
{
int i,j,k,try;
unsigned start,end;
//
// try a normal scan, then compress if not found
//
for (try=0;try<2;try++)
{
for (i=0;i<numblocks-1;i++)
{
if (blocks[i].attributes & PURGEBITS )
continue;
//
// blocks[i] cannot be written over, so try to allocate the
// new block right after it
//
start = blocks[i].start + blocks[i].length;
end = start + size;
j=i+1;
while (blocks[j].start < end)
{
if (!(blocks[j].attributes & PURGEBITS))
{
i = j-1;
goto lookmore; // a non purgable block is in the way
}
j++;
}
//
// purge the blocks in the way
//
for (k=i+1;k<j;j--)
RemoveBlock(k);
//
// allocate the new block
//
InsertBlock(i);
*(unsigned *)baseptr = start;
blocks[i+1].start = start;
blocks[i+1].length = size;
blocks[i+1].useptr = baseptr;
blocks[i+1].attributes = BASEATTRIBUTES;
return;
lookmore:;
}
//
// didn't find any space, so compress and try again
//
if (try==0)
MMSortMem();
}
//puts("");
//MMBlockDump(); // DEBUG
Quit ("Memory manager error: Out of memory!");
}
//==========================================================================
/*
=====================
=
= MMFreePtr
=
= Frees up a block and NULL's the pointer
=
=====================
*/
void MMFreePtr (memptr *baseptr)
{
RemoveBlock(FindBlock (baseptr));
TTLMainMem=16L*MMTotalFree();
}
//==========================================================================
/*
=====================
=
= MMSetPurge
=
= Sets the purge level for a block
=
=====================
*/
void MMSetPurge (memptr *baseptr, int purge)
{
int block;
unsigned attr;
block = FindBlock (baseptr);
attr = blocks[block].attributes;
attr &= 0xffff - PURGEBITS;
attr |= purge; // set bits in attributes
blocks[block].attributes = attr;
}
/*
=============================================================================
MMSortMem
=============================================================================
*/
//
// MoveParas
//
void MoveParaBase (unsigned source, unsigned dest, unsigned words)
{
asm mov cx,words
asm xor si,si
asm xor di,di
asm mov ax,source
asm mov bx,dest
asm mov ds,source
asm mov es,dest
asm rep movsw
asm mov ax,ss
asm mov ds,ax
}
void MoveParaBaseUp (unsigned source, unsigned dest, unsigned words)
{
asm mov cx,words
asm mov si,cx
asm dec si
asm shl si,1
asm mov di,si
asm mov ax,source
asm mov bx,dest
asm mov ds,source
asm mov es,dest
asm rep movsw
asm mov ax,ss
asm mov ds,ax
}
void MoveParas (unsigned source, unsigned dest, unsigned paragraphs)
{
if (source>dest)
{
asm cld
while (paragraphs>0xfff)
{
MoveParaBase (source,dest,0xfff*8);
source += 0xfff*8;
dest += 0xfff*8;
paragraphs -= 0xfff;
}
MoveParaBase (source,dest,paragraphs*8);
}
else
{
asm std
source+=paragraphs;
dest+=paragraphs;
while (paragraphs>0xfff)
{
source-=0xfff;
dest-=0xfff;
MoveParaBaseUp (source,dest,0xfff*8);
paragraphs -= 0xfff;
}
source-=paragraphs;
dest-=paragraphs;
MoveParaBaseUp (source,dest,paragraphs*8);
asm cld
}
}
/*
======================
=
= MMSortMem
=
= Sorts all non locked blocks so lower purge levels are lower in memory
= and all free space is at the top
=
======================
*/
int keyblock;
//
// PushUp
//
// Pushes the block (purgeable) as high in memory as possible
// must be BELOW keyblock
// If it can't fit above keyblock it will be freed
//
void PushUp (int move)
{
unsigned source,dest,size;
int i;
size = blocks[move].length;
source = blocks[move].start;
for (i=numblocks-1;i>keyblock;i--)
{
//
// if the block can fit under this block, move it
//
dest = blocks[i].start - size;
if (blocks[i-1].start+blocks[i-1].length <= dest)
{
//
// make a copy of block 'move' under block 'i'
//
InsertBlock (i-1);
blocks[i] = blocks[move];
blocks[i].start = dest;
*(blocks[i].useptr) = (void _seg *)dest; // modify the pointer to the new spot
MoveParas (source,dest,size);
break;
}
}
//
// erase original position
//
RemoveBlock (move);
keyblock--; // because a block below it was removed
}
//
// PushDown
//
// Push keyblock (unpurgable) as low in memory as possible
//
void PushDown (void)
{
unsigned source,dest,size,end,lowblock,checkblock,i;
size = blocks[keyblock].length;
source = blocks[keyblock].start;
//
// find the lowest space it can be moved into
//
for (lowblock = 0;lowblock<keyblock;lowblock++)
if (!(blocks[lowblock].attributes & PURGEBITS) ||
blocks[lowblock].attributes & LOCKBIT)
{
//
// found a locked or nonpurgable block below keyblock
//
// see if there is enough space to move block
//
dest = blocks[lowblock].start + blocks[lowblock].length;
end = dest+size;
//
// see if any of the blocks in the middle can be moved away
//
checkblock = lowblock+1;
while (checkblock < keyblock && blocks[checkblock].start<end)
{
if (!(blocks[checkblock].attributes & PURGEBITS) )
goto nofit; // can't fit between two locked blocks
//
// push the block up or remove it, in either case dropping
// keyblock and changing blocks[checkblock]
//
PushUp (checkblock);
}
//
// move it!
//
if (dest != source)
{
MoveParas (source,dest,size);
blocks[keyblock].start = dest;
*(blocks[keyblock].useptr) = (void _seg *)dest; // modify the pointer to the new spot
if (lowblock<keyblock-1)
{
//
// reorder the block records
//
tempblock = blocks[keyblock];
for (i=keyblock;i>lowblock+1;i--)
blocks[i]=blocks[i-1];
blocks[lowblock+1] = tempblock;
}
//MMBlockDump(); // DEBUG
}
return;
nofit:; // keep looking...
}
}
//
// MMSortMem
//
void MMSortMem (void)
{
unsigned i,source,dest;
keyblock = 0;
do
{
keyblock++;
//
// non-purgable, unlocked blocks will be pushed low in memory
//
if ( !(blocks[keyblock].attributes & PURGEBITS) &&
!(blocks[keyblock].attributes & LOCKBIT) )
PushDown ();
} while (keyblock<numblocks-1);
for (i=numblocks-2;i>0;i--)
{
//
// push all purgable blocks as high as possible
// Currently they are NOT moved around locked blocks!
//
if ( blocks[i].attributes & PURGEBITS )
{
source= blocks[i].start;
dest= blocks[i+1].start-blocks[i].length;
if (source!=dest)
{
MoveParas (source,dest,blocks[i].length);
blocks[i].start = dest;
*(blocks[i].useptr) = (void _seg *)dest; // modify the pointer to the new spot
}
}
}
PatchPointers(); // let the main program fix up any
// internal references
}
//==========================================================================
/*
=======================
=
= MMBlockDump
=
= Dewbug tool
=
=======================
*/
void MMBlockDump (void)
{
int i;
unsigned free;
fprintf (stdprn,"-------------\n");
for (i=0;i<numblocks;i++)
{
fprintf (stdprn,"Start:%4X\tLength:%4X\tAttr:%4X\tPtr:%p\n"
,blocks[i].start,blocks[i].length,blocks[i].attributes,blocks[i].useptr);
if (i<numblocks-1)
{
free = blocks[i+1].start - (blocks[i].start+blocks[i].length);
if (free)
fprintf (stdprn,"### Free:%X\n",free);
}
}
puts("");
}
//==========================================================================
/*
======================
=
= MMUnusedMemory
=
= Returns the total free space without purging
=
======================
*/
unsigned MMUnusedMemory (void)
{
int i;
unsigned free;
free = 0;
for (i=0;i<numblocks;i++)
{
if (i<numblocks-1)
free += blocks[i+1].start - (blocks[i].start+blocks[i].length);
}
return free;
}
//==========================================================================
/*
======================
=
= MMTotalFree
=
= Returns the total free space with purging
=
======================
*/
unsigned MMTotalFree (void)
{
int i;
unsigned free;
free = 0;
for (i=0;i<numblocks;i++)
{
if (blocks[i].attributes & PURGEBITS)
free += blocks[i].length;
if (i<numblocks-1)
free += blocks[i+1].start - (blocks[i].start+blocks[i].length);
}
return free;
}
//==========================================================================